/**
 * 数组操作工具函数
 */

// 导出统一的对象，避免命名冲突
export const arrUtil = {
  /**
   * 数组去重
   * @param arr 原始数组
   * @returns 去重后的数组
   */
  unique<T>(arr: T[]): T[] {
    if (!arr || !arr.length) return [];
    return [...new Set(arr)];
  },

  /**
   * 数组分组
   * @param arr 原始数组
   * @param keySelector 分组键选择器函数
   * @returns 分组后的对象
   */
  groupBy<T, K extends string | number | symbol>(
    arr: T[],
    keySelector: (item: T) => K
  ): Record<K, T[]> {
    if (!arr || !arr.length) return {} as Record<K, T[]>;
    
    return arr.reduce((result, item) => {
      const key = keySelector(item);
      if (!result[key]) {
        result[key] = [];
      }
      result[key].push(item);
      return result;
    }, {} as Record<K, T[]>);
  },

  /**
   * 数组扁平化（一维化）
   * @param arr 多维数组
   * @returns 扁平化后的一维数组
   */
  flatten<T>(arr: (T | T[])[]): T[] {
    if (!arr || !arr.length) return [];
    return arr.reduce<T[]>((result, item) => {
      return result.concat(Array.isArray(item) ? this.flatten(item as any) : item);
    }, []);
  },

  /**
   * 获取数组中的随机元素
   * @param arr 原始数组
   * @returns 随机元素
   */
  random<T>(arr: T[]): T | undefined {
    if (!arr || !arr.length) return undefined;
    const index = Math.floor(Math.random() * arr.length);
    return arr[index];
  },

  /**
   * 数组洗牌（随机排序）
   * @param arr 原始数组
   * @returns 随机排序后的新数组
   */
  shuffle<T>(arr: T[]): T[] {
    if (!arr || !arr.length) return [];
    const result = [...arr];
    for (let i = result.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [result[i], result[j]] = [result[j], result[i]];
    }
    return result;
  }
}; 